Equipe 03 :
Lou Dutertre-Thouan, Louey Guinoubi, Ethan Swica, Raphaël Linard, Flavio De Barros Barbosa, Nathan Bayeul

1. Introduction
2. Étape 1 : Descente de la pente
2. Étape 2 : Looping
3. Étape 3 : Saut en l’air
4. Étape 4 : Piste d’arrivée
5. Circuit complet
6. Comparaison des valeurs obtenues
7. Critiques
8. Conclusion
Owen Shaw à proposer un défi à Dom Torreto de remporter une course de voiture sur circuit.
Ce circuit est composé de différentes étapes :
Un ami de Dom Torreto, Tej Parker, membre de notre équipe doit choisir la bonne voiture pour faire gagner la course à Dom. Pour ce faire notre équipe doit procéder à une étude du circuit pour savoir quelle voiture sera la plus adaptée.
Dom Torreto aimerait remporter la course avec sa Dodge qui est sa voiture de prédilection.
Pour ce troisième livrable nous devons réaliser un rapport (et un code paramétrable) qui détaillera la résolution des équations du mouvement (de manière numérique) énoncées dans le livrable 2.

Étape 1 : Descente de la pente
Étape 2 : Looping
Étape 3 : Saut en l’air
Étape 4 : Piste d’arrivée
Toutes les étapes du circuit seront étudiées sur un référentiel galiléen

Lexique :
, la masse de la voiture (en kg) ;
, la constante gravitationnelle (≈ 9.81N/kg) ;
, l’angle en degrés ;
;
, le coefficient de frottement dynamique entre la route et les pneus ;
, l’accélération moyenne de la voiture (en m/s) ;
, la masse volumique du fluide, ici l’air (en g/L) ;
, la surface de contact (en m) ;
, le coefficient de trainée ;
, le coefficient de portance ;
, la vitesse (en km/h) ;
Les fonctions présentées, plus tard dans ce livrable, ne fonctionneront pas sans ces variables et bibliothèques
u=0.1 #coefficient de frottement
g=9.81 #constante gravitationnelle
rho=1.293 # Masse volumique de l'air à 20°C
Dodge={"masse":1760,"accm":5.1,"longueur":5.28,"largeur":1.95,"hauteur":1.35,"trainee":0.38}
Toyota={"masse":1615,"accm":5.4,"longueur":4.51,"largeur":1.81,"hauteur":1.27,"trainee":0.29}
Chevrolet={"masse":1498,"accm":5.3,"longueur":4.72,"largeur":1.88,"hauteur":1.3,"trainee":0.35}
Mazda={"masse":1385,"accm":5.2,"longueur":4.3,"largeur":1.75,"hauteur":1.23,"trainee":0.28}
Nissan={"masse":1540,"accm":5.8,"longueur":4.6,"largeur":1.79,"hauteur":1.36,"trainee":0.34}
Mitsubishi={"masse":1600,"accm":5,"longueur":4.51,"largeur":1.81,"hauteur":1.48,"trainee":0.28}
On importe la bibliothèque “math” pour effectuer des calculs mathématiques, ainsi que la bibliothèque “matplotlib.pyplot” pour effectuer des graphiques.
import math as m
import matplotlib.pyplot as plt
On utilisera cette formule pour résoudre nos équations différentielles.


Projection sur l’axe :
( )
Donc :
Soit une forme plus simple :
On trouve une équation différentielle de la forme
Projection sur l’axe :
( )
Donc :
Alors : qui est à réutiliser dans le calcul pour les forces constantes !
En conclusion, la vitesse de la voiture sera le résultat de l’équation différentielle de .
# Etape 1 pour la pente
def Pente(voiture,pas,ailerons=0,jupe = 0,booster = 0):
# Initialisation des variables si on utilise les accessoires d'amélioration
# Initilialisation de variables
vitessei=0
alpha=3.70*(m.pi/180)
distance = 0
t=0
# Coefficient de trainée
Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
# Initialisation de variables
mvoiture=voiture["masse"]+ailerons*30+jupe*15
accvoiture=voiture["accm"]+((voiture["accm"]*30)/100)*booster
# Forces
poids = (mvoiture*g*m.sin(alpha))
k = -(1/2)*rho*(voiture["largeur"]*voiture["hauteur"])*Cx
N = (m.cos(alpha) *mvoiture*g)
frottement = N*u
force_constante=poids-frottement
# Tant qu'on arrive pas au bout de notre pente
while not distance>=31:
t += pas
Ftotale = (k*vitessei**2)+force_constante
vitessei = vitessei + ((Ftotale/mvoiture) + accvoiture)*pas
# Réecriture de l'équation différentielle avec la méthode d'Euler
distance += vitessei*pas
vitesse_finale = vitessei
temps_final = t
print("Le temps final pour l'étape 1 est de : "+str(temps_final))
print("La vitesse finale pour l'étape 1 est de : "+str(vitesse_finale))
return vitesse_finale,temps_final
En exemple, on calcule avec la Dodge qui ne dispose d’aucun équipement.
Pente(Dodge,0.0001)
Le temps final pour l'étape 1 est de :3.618100000003211
La vitesse finale pour l'étape 1 est de : 17.070908072743308


Système n°1 : Bilan polaire
En dérivant , et en simplifiant on trouve ce résultat :
En dérivant , et en simplifiant on trouve ce résultat :
Avec L, la distance entre le centre du looping et de la voiture.
Système n°2 : Bilan des forces appliquées à la voiture
Sur l’axe puis sur l’axe :
Grâce à ces deux systèmes nous pouvons obtenir ces 2 équations différentielles :
Pour obtenir la normale étant donné que nous ne savons pas comment l’a calculer ici, nous devons utiliser l’équation pour et isoler pour l’obtenir et la réinjecter dans l’autre équation.
Ainsi nous obtenons :
# Etape 2 pour le looping
def Looping(voiture, vitessei, pas, ailerons=0,jupe=0, booster=0):
# Initialisation des variables si on utilise les accessoires d'amélioration
# Initialisation des listes
x2 = [0]
y2 = [0]
t = [0]
# Paramètres de la voiture et de l'environnement
L = 6 # Rayon du looping
w = [vitessei / L] # Vitesse angulaire initiale
theta = [0] # Angle initial
# Coefficient de trainée
Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
# Initialisation de variables
mvoiture = voiture["masse"]+ailerons*30+jupe*15
accvoiture = voiture["accm"]+((voiture["accm"]*30)/100)*booster
# Forces
k = (1/2)*rho*voiture["largeur"]*voiture["hauteur"]*Cx
P = mvoiture * g
# Tant qu'on a pas fait le tour du cercle
while theta[-1] < 2 * m.pi:
# Mise à jour du pas
t.append(t[-1] + pas)
nouveau_theta = theta[-1] + (pas * w[-1])
# Sépération de plusieurs équations
Ftotale1 = -(k*(w[-1]**2)*(L**2))
Ftotale2 = -(u*(P*m.cos(theta[-1])+L*(w[-1]**2)*mvoiture))
Ftotale3 = -(P*m.sin(theta[-1]))
# Rassemblement des équations
FtotaleF = Ftotale1 + Ftotale2 + Ftotale3
# Calcul de l'accélération angulaire
acceleration_angulaire = (accvoiture/L) + FtotaleF/(mvoiture * L)
# Calcul de la nouvelle vitesse angulaire
nouvelle_vitesse_angulaire = w[-1] + (pas * acceleration_angulaire)
# Mise à jour des listes
theta.append(nouveau_theta)
w.append(nouvelle_vitesse_angulaire)
# Calcul en fonction de la force qui nous tire vers le bas
vitesse_decrochage = m.sqrt(g*L*abs(m.cos(theta[-1])))
v = w[-1] * L
if v < vitesse_decrochage :
print("Decrochage")
plt.figure()
plt.plot(x2, y2)
plt.xlabel("x (m)")
plt.ylabel("y (m)")
plt.title("Trajectoire de la voiture")
plt.axis([-L, L, 0, 2 * L])
plt.grid()
plt.show()
# Graphique de la vitesse
v = [wi * L for wi in w]
# Reprise de toutes les valeures !
plt.figure()
plt.plot(t, v)
plt.xlabel("Temps (s)")
plt.ylabel("Vitesse (m/s)")
plt.title("Vitesse en fonction du temps")
plt.grid()
plt.show()
return None,None
distance = v * pas
# Gestion des coordonnées X et Y
x2.append(x2[-1] + m.cos(nouveau_theta) * distance)
y2.append(y2[-1] + m.sin(nouveau_theta) * distance)
# Graphique de la trajectoire
plt.figure()
plt.plot(x2, y2,color = (1,0,1))
plt.xlabel("x (m)")
plt.ylabel("y (m)")
plt.title("Trajectoire de la voiture")
plt.axis([-L, L, 0, 2 * L])
plt.grid()
plt.show()
# Graphique de la vitesse
v = [wi * L for wi in w]
# Reprise de toutes les valeures pour la vitesse grâce à la liste w
plt.plot(t, v,color = (0,0,1))
plt.xlabel("Temps (s)")
plt.ylabel("Vitesse (m/s)")
plt.title("Vitesse en fonction du temps")
plt.grid()
plt.show()
print("Le temps final pour l'étape 2 est de : "+str(t[-1]))
print("La vitesse finale pour l'étape 2 est de : "+str(v[-1]))
return v[-1], t[-1]
Le graphique concerne uniquement la dodge car il change selon la voiture.

Le graphique concerne uniquement la dodge car il change selon la voiture.

En exemple, on calcule avec la Dodge qui ne dispose d’aucun équipement.
Looping(Dodge,Pente(Dodge,0.0001)[0],0.0001)
Le temps final pour l'étape 2 est de : 2.616000000001096
La vitesse finale pour l'étape 2 est de : 19.422966784313846
#Trouver la vitesse minimum pour effectuer le looping (ici pour la Dodge)
def trouverx():
v=21
bon=Looping(Dodge,v,0.001)[0] # Etape avec quelle voiture pour vérifier son minimum
while bon!=None:
v=v-0.001
# Etape avec quelle voiture pour vérifier son minimum
bon = Looping(Dodge,v,0.001)[0]
return v
print(trouverx())
13.525999999996484
En conclusion, chaque voiture possède une vitesse minimale différente, à l’entrée du looping pour pouvoir le franchir. La Dodge doit avoir une vitesse supérieure ou égale à 13.526 m/s pour pouvoir le franchir. Tandis que la Nissan doit posséder une vitesse supérieure ou égale à 12.313 m/s.

Sur l’axe :
( )
Donc :
Équation différentielle :
Avec
Sur l’axe :
( )
Donc :
Équation différentielle :
Avec
Après la résolution de la vitesse et , il nous restera à faire le module pour obtenir la vitesse réelle.
# Etape 3 pour le ravin
def Ravin(voiture,pas,vitessei,ailerons=0,jupe = 0):
# Initialisation des variables si on utilise les accessoires d'amélioration
# Initialisation des listes
X3=[0]
Y3=[1]
# Initialisation de variables
distancex = 0
distancey=1
vitesseX=vitessei
vitesseX1=vitesseX
vitesseY=0
t=0
# Coefficient de trainée
Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
# Coefficient de portance
Cz=0.3 +0.03*ailerons
# Initialisation de variables
mvoiture=voiture["masse"]+ailerons*30+jupe*15
# Forces
kx = -(1/2)*rho*voiture["largeur"]*voiture["hauteur"]*Cx
ky = (1/2)*rho*(voiture["largeur"]*voiture["longueur"]+0.8*ailerons)*Cz
# Tant qu'on ne touche pas le sol
while not distancey<0:
vitesseX1=vitesseX
t+=pas
FtotaleX = (kx*vitesseX**2)
vitesseX=vitesseX+(FtotaleX/mvoiture)*pas
distancex+=vitesseX*pas
X3.append(distancex)
FtotaleY = (ky*vitesseY**2)
vitesseY=vitesseY+((FtotaleY/mvoiture)-g)*pas
distancey+=vitesseY*pas
Y3.append(distancey)
plt.plot(X3,Y3,color = (0,0,1))
plt.xlabel("x (m)")
plt.ylabel("y (m)")
plt.title("Trajectoire de la voiture lors de l'étape n°3")
plt.grid()
plt.axis([0,X3[-1]+0.1,0,1])
plt.show()
if X3[-2]<9:
return None,None,None
print("Le temps final pour l'étape 3 est de : "+str(t-pas))
print("La vitesse finale pour l'étape 3 est de : "+str(vitesseX))
return vitesseX1,t-pas,distancex-9-vitesseX1*pas
Le graphique concerne uniquement la Nissan car il change selon la voiture.

En exemple, on calcule avec la Nissan qui ne dispose d’aucun équipement.
Ravin(Nissan,0.0001,Looping(Nissan,Pente(Nissan,0.0001)[0],0.0001)[0])
Le temps final pour l'étape 3 est de : 0.4514999999999666
La vitesse finale pour l'étape 3 est de : 20.40772995771356
#Trouver la vitesse minimum pour franchir le Ravin (ici pour la Nissan)
def trouverx():
v=21
bon= Ravin(Nissan,0.001,v)[0] # Etape avec quelle voiture pour vérifier son minimum
while bon!=None:
v=v-0.001
# Etape avec quelle voiture pour vérifier son minimum
bon = Ravin(Nissan,0.001,v)[0]
return v
print(trouverx())
19.985999999993872
En conclusion, chaque voiture possède une vitesse minimale à la sortie du looping pour pouvoir franchir le ravin. La Nissan doit avoir une vitesse supérieure ou égale à 19.986 m/s pour pouvoir le franchir.

Projection sur l’axe :
( )
Donc :
Équation différentielle:
Avec
Projection sur l’axe :
( )
Donc :
Alors :
En conclusion, la vitesse finale sera uniquement celle de la résolution de l’équation .
# Etape 4 pour l'arrivée
def Arrivee(voiture,pas,vitessei,distancex,ailerons= 0,jupe = 0,booster = 0):
# Initialisation des variables si on utilise les accessoires d'amélioration
# Initialisation de variables
distance = distancex
t=0
# Coefficient de trainée
Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
# Initialisation de variables
mvoiture=voiture["masse"]+ailerons*30+jupe*15
accvoiture=voiture["accm"]+((voiture["accm"]*30)/100)*booster
# Forces
k = -(1/2)*rho*voiture["largeur"]*voiture["hauteur"]*Cx
N = mvoiture*g
frottement = N*u
# Tant qu'on arrive pas à la ligne d'arrivée
while not distance>=10:
t += pas
Ftotale = (k*vitessei**2)-frottement
vitessei=vitessei + ((Ftotale/mvoiture) + accvoiture)*pas
distance += vitessei*pas
print("Le temps final pour l'étape 4 est de : "+str(t))
print("La vitesse finale pour l'étape 4 est de : "+str(vitessei))
return vitessei,t
En exemple, on calcule avec la Nissan qui ne dispose d’aucun équipement.
Arrivee(Nissan,0.0001,Ravin(Nissan,0.0001,Looping(Nissan,Pente(Nissan,0.0001)[0],0.0001)[0])[0],Ravin(Nissan,0.0001,Looping(Nissan,Pente(Nissan,0.0001)[0],0.0001)[0])[2])
Le temps final pour l'étape 4 est de : 0.4551999999999662
La vitesse finale pour l'étape 4 est de : 22.528390857814273

import math as m
import matplotlib.pyplot as plt
# Etape pour la pente
def Pente(voiture,pas,ailerons=0,jupe = 0,booster = 0):
# Initialisation des variables si on utilise les accessoires d'amélioration
# Initilialisation de variables
vitessei=0
alpha=3.70*(m.pi/180)
distance = 0
t=0
# Coefficient de trainée
Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
# Initialisation de variables
mvoiture=voiture["masse"]+ailerons*30+jupe*15
accvoiture=voiture["accm"]+((voiture["accm"]*30)/100)*booster
# Forces
poids = (mvoiture*g*m.sin(alpha))
k = -(1/2)*rho*(voiture["largeur"]*voiture["hauteur"])*Cx
N = (m.cos(alpha) *mvoiture*g)
frottement = N*u
force_constante=poids-frottement
# Tant qu'on arrive pas au bout de notre pente
while not distance>=31:
t += pas
Ftotale = (k*vitessei**2)+force_constante
vitessei = vitessei + ((Ftotale/mvoiture) + accvoiture)*pas
# Réecriture de l'équation différentielle avec la méthode d'Euler
distance += vitessei*pas
vitesse_finale = vitessei
temps_final = t
print("Le temps final pour l'étape 1 est de : "+str(temps_final))
print("La vitesse finale pour l'étape 1 est de : "+str(vitesse_finale))
return vitesse_finale,temps_final
# Etape 2 pour le looping
def Looping(voiture, vitessei, pas, ailerons=0,jupe=0, booster=0):
# Initialisation des variables si on utilise les accessoires d'amélioration
# Initialisation des listes
x2 = [0]
y2 = [0]
t = [0]
# Paramètres de la voiture et de l'environnement
L = 6 # Rayon du looping
w = [vitessei / L] # Vitesse angulaire initiale
theta = [0] # Angle initial
# Coefficient de trainée
Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
# Initialisation de variables
mvoiture = voiture["masse"]+ailerons*30+jupe*15
accvoiture = voiture["accm"]+((voiture["accm"]*30)/100)*booster
# Forces
k = (1/2)*rho*voiture["largeur"]*voiture["hauteur"]*Cx
P = mvoiture * g
# Tant qu'on a pas fait le tour du cercle
while theta[-1] < 2 * m.pi:
# Mise à jour du pas
t.append(t[-1] + pas)
nouveau_theta = theta[-1] + (pas * w[-1])
# Sépération de plusieurs équations
Ftotale1 = -(k*(w[-1]**2)*(L**2))
Ftotale2 = -(u*(P*m.cos(theta[-1])+L*(w[-1]**2)*mvoiture))
Ftotale3 = -(P*m.sin(theta[-1]))
# Rassemblement des équations
FtotaleF = Ftotale1 + Ftotale2 + Ftotale3
# Calcul de l'accélération angulaire
acceleration_angulaire = (accvoiture/L) + FtotaleF/(mvoiture * L)
# Calcul de la nouvelle vitesse angulaire
nouvelle_vitesse_angulaire = w[-1] + (pas * acceleration_angulaire)
# Mise à jour des listes
theta.append(nouveau_theta)
w.append(nouvelle_vitesse_angulaire)
# Calcul en fonction de la force qui nous tire vers le bas
vitesse_decrochage = m.sqrt(g*L*abs(m.cos(theta[-1])))
v = w[-1] * L
if v < vitesse_decrochage :
print("Decrochage")
plt.figure()
plt.plot(x2, y2)
plt.xlabel("x (m)")
plt.ylabel("y (m)")
plt.title("Trajectoire de la voiture")
plt.axis([-L, L, 0, 2 * L])
plt.grid()
plt.show()
# Graphique de la vitesse
v = [wi * L for wi in w]
# Reprise de toutes les valeures !
plt.figure()
plt.plot(t, v)
plt.xlabel("Temps (s)")
plt.ylabel("Vitesse (m/s)")
plt.title("Vitesse en fonction du temps")
plt.grid()
plt.show()
return None,None
distance = v * pas
# Gestion des coordonnées X et Y
x2.append(x2[-1] + m.cos(nouveau_theta) * distance)
y2.append(y2[-1] + m.sin(nouveau_theta) * distance)
# Graphique de la trajectoire
plt.figure()
plt.plot(x2, y2,color = (1,0,1))
plt.xlabel("x (m)")
plt.ylabel("y (m)")
plt.title("Trajectoire de la voiture")
plt.axis([-L, L, 0, 2 * L])
plt.grid()
plt.show()
# Graphique de la vitesse
v = [wi * L for wi in w]
# Reprise de toutes les valeures pour la vitesse grâce à la liste w
plt.plot(t, v,color = (0,0,1))
plt.xlabel("Temps (s)")
plt.ylabel("Vitesse (m/s)")
plt.title("Vitesse en fonction du temps")
plt.grid()
plt.show()
print("Le temps final pour l'étape 2 est de : "+str(t[-1]))
print("La vitesse finale pour l'étape 2 est de : "+str(v[-1]))
return v[-1], t[-1]
# Etape 3 pour le ravin
def Ravin(voiture,pas,vitessei,ailerons=0,jupe = 0):
# Initialisation des variables si on utilise les accessoires d'amélioration
# Initialisation des listes
X3=[0]
Y3=[1]
# Initialisation de variables
distancex = 0
distancey=1
vitesseX=vitessei
vitesseX1=vitesseX
vitesseY=0
t=0
# Coefficient de trainée
Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
# Coefficient de portance
Cz=0.3 +0.03*ailerons
# Initialisation de variables
mvoiture=voiture["masse"]+ailerons*30+jupe*15
# Forces
kx = -(1/2)*rho*voiture["largeur"]*voiture["hauteur"]*Cx
ky = (1/2)*rho*(voiture["largeur"]*voiture["longueur"]+0.8*ailerons)*Cz
# Tant qu'on ne touche pas le sol
while not distancey<0:
vitesseX1=vitesseX
t+=pas
FtotaleX = (kx*vitesseX**2)
vitesseX=vitesseX+(FtotaleX/mvoiture)*pas
distancex+=vitesseX*pas
X3.append(distancex)
FtotaleY = (ky*vitesseY**2)
vitesseY=vitesseY+((FtotaleY/mvoiture)-g)*pas
distancey+=vitesseY*pas
Y3.append(distancey)
plt.plot(X3,Y3,color = (0,0,1))
plt.xlabel("x (m)")
plt.ylabel("y (m)")
plt.title("Trajectoire de la voiture lors de l'étape n°3")
plt.grid()
plt.axis([0,X3[-1]+0.1,0,1])
plt.show()
if X3[-2]<9:
return None,None,None
print("Le temps final pour l'étape 3 est de : "+str(t-pas))
print("La vitesse finale pour l'étape 3 est de : "+str(vitesseX))
return vitesseX1,t-pas,distancex-9-vitesseX1*pas
# Etape 4 pour l'arrivée
def Arrivee(voiture,pas,vitessei,distancex,ailerons= 0,jupe = 0,booster = 0):
# Initialisation des variables si on utilise les accessoires d'amélioration
# Initialisation de variables
distance = distancex
t=0
# Coefficient de trainée
Cx=voiture["trainee"]-((voiture["trainee"]*5)/100)*jupe
# Initialisation de variables
mvoiture=voiture["masse"]+ailerons*30+jupe*15
accvoiture=voiture["accm"]+((voiture["accm"]*30)/100)*booster
# Forces
k = -(1/2)*rho*voiture["largeur"]*voiture["hauteur"]*Cx
N = mvoiture*g
frottement = N*u
# Tant qu'on arrive pas à la ligne d'arrivée
while not distance>=10:
t += pas
Ftotale = (k*vitessei**2)-frottement
vitessei=vitessei + ((Ftotale/mvoiture) + accvoiture)*pas
distance += vitessei*pas
print("Le temps final pour l'étape 4 est de : "+str(t))
print("La vitesse finale pour l'étape 4 est de : "+str(vitessei))
return vitessei,t
# Circuit complet
def Circuit(voiture,pas,ailerons=0,jupe = 0,booster = 0,etapebooster=0):
# Vérification
assert(ailerons==0 or ailerons==1),"1 si vous voulez mettre l'ailerons,0 sinon."
assert(jupe==0 or jupe==1),"1 si vous voulez mettre la jupe,0 sinon."
assert(booster==0 or booster==1),"1 si vous voulez utiliser le booster,0sinon."
assert((etapebooster==0 and booster==0) or ((etapebooster==1 or etapebooster==2 or etapebooster==4 )and booster==1)),"0 si le booster n'est pas utiliser,sinon 1 ;2;4 cela là où vous souahitez l'utilisé. "
# Initialisation des variables
vitesse=0
temps_total=0
t_temp=0
# Gestion des boosters
if etapebooster==1:
vitesse,temps_total=Pente(voiture,pas,ailerons,jupe,1)
vitesse,t_temp=Looping(voiture, vitesse, pas, ailerons,jupe,0)
if vitesse==None:
return "insuffisante looping",-1
temps_total+=t_temp
vitesse,t_temp,distance=Ravin(voiture,pas,vitesse,ailerons,jupe)
if vitesse==None:
return "insuffisante ravin",-1
temps_total+=t_temp
vitesse,t_temp=Arrivee(voiture,pas,vitesse,distance,ailerons,jupe,0)
return vitesse,temps_total+t_temp,"Victoire"
if etapebooster==2:
vitesse,temps_total=Pente(voiture,pas,ailerons,jupe,0)
vitesse,t_temp=Looping(voiture, vitesse, pas, ailerons,jupe,1)
if vitesse==None:
return "insuffisante looping",-1
temps_total+=t_temp
vitesse,t_temp,distance=Ravin(voiture,pas,vitesse,ailerons,jupe)
if vitesse==None:
return "insuffisante ravin",-1
temps_total+=t_temp
vitesse,t_temp=Arrivee(voiture,pas,vitesse,distance,ailerons,jupe,0)
return vitesse,temps_total+t_temp,"Victoire"
if etapebooster==4:
vitesse,temps_total=Pente(voiture,pas,ailerons,jupe,0)
vitesse,t_temp=Looping(voiture, vitesse, pas, ailerons,jupe,0)
if vitesse==None:
return "insuffisante looping",-1
temps_total+=t_temp
vitesse,t_temp,distance=Ravin(voiture,pas,vitesse,ailerons,jupe)
if vitesse==None:
return "insuffisante ravin",-1
temps_total+=t_temp
vitesse,t_temp=Arrivee(voiture,pas,vitesse,distance,ailerons,jupe,1)
return vitesse,temps_total+t_temp,"Victoire"
vitesse,temps_total=Pente(voiture,pas,ailerons,jupe,0)
vitesse,t_temp=Looping(voiture, vitesse, pas, ailerons,jupe,0)
if vitesse==None:
return "insuffisante looping",-1
temps_total+=t_temp
vitesse,t_temp,distance=Ravin(voiture,pas,vitesse,ailerons,jupe)
if vitesse==None:
return "insuffisante ravin",-1
temps_total+=t_temp
vitesse,t_temp=Arrivee(voiture,pas,vitesse,distance,ailerons,jupe,0)
return vitesse,temps_total+t_temp,"Victoire"
# Trouver la vitesse minimum pour franchir le ravin ou le looping
# Ici, on a choisi la Nissan dans le ravin mais on peut changer
def trouverx():
v=21
bon= Ravin(Nissan,0.001,v)[0] # Etape avec quelle voiture pour vérifier son minimum
while bon!=None:
v=v-0.001
# Etape avec quelle voiture pour vérifier son minimum
bon = Ravin(Nissan,0.001,v)[0]
return v
u=0.1 #coefficient de frottement
g=9.81 #constante gravitationnelle
rho=1.293 # Masse volumique de l'air à 20°C
# Initialisation des dictionnaires
Dodge={"masse":1760,"accm":5.1,"longueur":5.28,"largeur":1.95,"hauteur":1.35,"trainee":0.38}
Toyota={"masse":1615,"accm":5.4,"longueur":4.51,"largeur":1.81,"hauteur":1.27,"trainee":0.29}
Chevrolet={"masse":1498,"accm":5.3,"longueur":4.72,"largeur":1.88,"hauteur":1.3,"trainee":0.35}
Mazda={"masse":1385,"accm":5.2,"longueur":4.3,"largeur":1.75,"hauteur":1.23,"trainee":0.28}
Nissan={"masse":1540,"accm":5.8,"longueur":4.6,"largeur":1.79,"hauteur":1.36,"trainee":0.34}
Mitsubishi={"masse":1600,"accm":5,"longueur":4.51,"largeur":1.81,"hauteur":1.48,"trainee":0.28}
print("Résultat pour la Dodge")
print(Circuit(Dodge,0.0001,0,0,0,0))
print("vitesse_finale , temps_total , Course terminé ? ")
Résultat pour la Dodge
Le temps final pour l'étape 1 est de : 3.618100000003211
La vitesse finale pour l'étape 1 est de : 17.070908072743308
Le temps final pour l'étape 2 est de : 2.616000000001096
La vitesse finale pour l'étape 2 est de : 19.422966784313846
('insuffisante ravin', -1)
vitesse_finale , temps_total , Course terminé ?
print("Résultat pour la Dodge")
print(Circuit(Dodge,0.0001,1,1,1,1)) # Version la plus rapide de la Dodge
print("vitesse_finale , temps_total , Course terminé ? ")
Résultat pour la Dodge
Le temps final pour l'étape 1 est de : 3.146600000002216
La vitesse finale pour l'étape 1 est de : 19.63515819709627
Le temps final pour l'étape 2 est de : 2.306500000000443
La vitesse finale pour l'étape 2 est de : 20.091094834320813
Le temps final pour l'étape 3 est de : 0.4514999999999666
La vitesse finale pour l'étape 3 est de : 20.029237790536214
Le temps final pour l'étape 4 est de : 0.4741999999999641
La vitesse finale pour l'étape 4 est de : 21.911447129182502
(21.911447129182502, 6.378800000002589, 'Victoire')
vitesse_finale , temps_total , Course terminé ?
print("Résultat pour la Nissan")
print(Circuit(Nissan,0.0001,0,0,0,0))
print("vitesse_finale , temps_total , Course terminé ? ")
Résultat pour la Nissan
Le temps final pour l'étape 1 est de : 3.3776000000027033
La vitesse finale pour l'étape 1 est de : 18.290174142188583
Le temps final pour l'étape 2 est de : 2.364400000000565
La vitesse finale pour l'étape 2 est de : 20.47329242593228
Le temps final pour l'étape 3 est de : 0.4514999999999666
La vitesse finale pour l'étape 3 est de : 20.40772995771356
Le temps final pour l'étape 4 est de : 0.4551999999999662
La vitesse finale pour l'étape 4 est de : 22.528390857814273
(22.528390857814273, 6.648700000003201, 'Victoire')
vitesse_finale , temps_total , Course terminé ?
print("Résultat pour la Nissan")
print(Circuit(Nissan,0.0001,1,1,1,1)) # Version la plus rapide de la Nissan
print("vitesse_finale , temps_total , Course terminé ? ")
Résultat pour la Nissan
Le temps final pour l'étape 1 est de : 2.940500000001781
La vitesse finale pour l'étape 1 est de : 21.014712319683287
Le temps final pour l'étape 2 est de : 2.1078000000000237
La vitesse finale pour l'étape 2 est de : 21.19503346594931
Le temps final pour l'étape 3 est de : 0.4514999999999666
La vitesse finale pour l'étape 3 est de : 21.13016629254108
Le temps final pour l'étape 4 est de : 0.4268999999999693
La vitesse finale pour l'étape 4 est de : 23.12033687967721
(23.12033687967721, 5.92670000000174, 'Victoire')
vitesse_finale , temps_total , Course terminé ?
On ne compare que la Dodge et la Nissan car la Nissan est la voiture la plus rapide et la Dodge est la voiture de prédilection de Dom Torreto.
Pour pouvoir effectuer les comparaisons, on utilise les données des voitures avec leur version la plus rapide.
Vitesse de la Dodge 19.635 m/s
Vitesse de la Nissan 21.015 m/s
Différence : 1.380 m/s
La Nissan est environ 1.380 m/s plus rapide que la Dodge.
Vitesse minimale de la Dodge 13.526 m/s
Vitesse minimale de la Nissan 12.315 m/s
Différence : 1.211 m/s
La Dodge doit avoir une vitesse d’entrée plus importante que celle de la Nissan (ici, environ 1.211 m/s de plus) pour pouvoir réussir le looping.
Vitesse de la Dodge 20.091 m/s
Vitesse de la Nissan 21.195 m/s
Différence : 1.104 m/s
La Nissan est environ 1.104 m/s plus rapide que la Dodge.
Vitesse minimale de la Dodge 19.986 m/s
Vitesse minimale de la Nissan 19.986 m/s
Différence : 0 m/s
La Dodge et la Nissan doivent avoir une vitesse minimum d’environ 19.986 m/s à la sortie du looping pour pouvoir réussir le saut.
Vitesse de la Dodge 21.911 m/s
Vitesse de la Nissan 23.120 m/s
Différence : 1.209 m/s
La Nissan finit la course avec une vitesse supérieure à la Dodge de 1.209 m/s.
Temps de la Dodge 6.379 s
Temps de la Nissan 5.927 s
Différence : 0.452 s
La Nissan finit la course avec un temps inférieur à la Dodge de 0.452 s.
Malgré avoir trouvé des résultats, ils ne sont pas fiables à 100% car la surface utilisée pour les voitures n’est pas parfaite. Nous avons calculer la surface des voitures comme des rectangles, ce qui n’est pas réellement vrai. Ensuite, nous avons négligé la vitesse de l’air ainsi que les conditions météorologique car elles n’influaient pas beaucoup les résultats. Cependant, on peut dire que nos calculs de chaque étape sont cohérents.
En conclusion, nous avons pu déterminer que la Nissan était la voiture la plus rapide pour remporter la course, qu’elle soit équipée ou non.
Cependant, la Dodge avec des équipements comme un booster à l’étape 1, une jupe frontale et des ailerons de surfaces peut aussi gagner. En effet, la voiture de prédilection de Dom Torreto est moins rapide que la Nissan mais elle est plus rapide que celle de Tej Parker.
Tej parker parcourt le circuit en environ 8 secondes, alors que la Dodge peut le parcourir en environ 6,379 secondes. Puis la Nissan avec les mêmes équipements, en environ 5,927 secondes.
Dom Torreto a donc le choix d’effectuer la course avec la Nissan ou alors avec sa Dodge.